package scene;

import javax.media.opengl.GL;
import javax.media.opengl.glu.GLU;

import com.sun.opengl.util.GLUT;


public class Dessin {

	static public GLU glu = new GLU();
	static public GLUT glut = new GLUT();
	private GLScene3D glScene3D;



	public static int REPERE;


	/**
	 * constructeur referen�ant une scene3D
	 * @param _maglscene3d
	 */
	public Dessin(GLScene3D _maglscene3d)
	{
		glu = new GLU();
		glut = new GLUT();
		setGlScene3D(_maglscene3d);
	}


	/**
	 *
	 * @param gl
	 * @param x1 : coordonnee X de la 1ere extremite du segment dans la scene
	 * @param y1 : coordonnee Y de la 1ere extremite du segment dans la scene
	 * @param z1 : coordonnee Z de la 1ere extremite du segment dans la scene
	 * @param x2 : coordonnee X de la seconde extremite du segment dans la scene
	 * @param y2 : coordonnee Y de la seconde extremite du segment dans la scene
	 * @param z2 : coordonnee Z de la seconde extremite du segment dans la scene
	 * @param _couleur : instance de la classe Couleur
	 */
	static public void drawLine(GL gl, double x1, double y1, double z1, double x2, double y2, double z2, Couleur _couleur)
	{
		gl.glPushMatrix();
		setLumiere(gl, false);

		gl.glBegin(GL.GL_LINES);
		gl.glColor4f(_couleur.getGFloat4Value()[0],_couleur.getGFloat4Value()[1],_couleur.getGFloat4Value()[2],
				_couleur.getGFloat4Value()[3]);
		gl.glVertex3d(x1,y1,z1);
		gl.glVertex3d(x2,y2,z2);
		gl.glEnd();

		setLumiere(gl,true);
		gl.glPopMatrix();

	}

	/**
	 *
	 * @param gl
	 * @param x : coordonnee X du centre du cube
	 * @param y : coordonnee Y du centre du cube
	 * @param z : coordonnee Z du centre du cube
	 * @param cote : largeur du cote du cube (et non pas une demi largeur !!!!)
	 * @param _couleur :  instance de la classe Couleur
	 */
	public static void drawCube(GL gl, double x, double y, double z, double cote, Couleur _couleur)
	{

		gl.glPushMatrix();
        gl.glTranslated(x,y,z);
        //setLumiere(gl,false);

        gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, _couleur.getColor4fv());
        gl.glColor4fv(_couleur.getColor4fv());
        //gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, _couleur.getColor4fv());
        //gl.glMaterialfv(GL.GL_BACK, GL.GL_SPECULAR, _couleur.getColor4fv());
		glut.glutSolidCube((float)(cote));
		//setLumiere(gl,true);
		gl.glPopMatrix();

	}





	/**
	 *
	 * @param gl : ressources GL
	 * @param texte : instance de la classe String pour preciser la chaine de caracteres � afficher
	 * @param x : coordonnee X de placement du premier caractere de la chaine de caracteres
	 * @param y : coordonnee Y de placement du premier caractere de la chaine de caracteres
	 * @param z : coordonnee Z de placement du premier caractere de la chaine de caracteres
	 * @param couleur : instance de la classe Couleur
	 */
    public static void drawText2D(GL gl, String texte, double x, double y, double z, Couleur couleur)
    {
        gl.glPushMatrix();
        setLumiere(gl,false);
        gl.glColor4fv(couleur.getColor4fv());

		gl.glRasterPos3d(x, y, z);
        glut.glutBitmapString(GLUT.BITMAP_HELVETICA_12, texte);

        setLumiere(gl,true);
        gl.glPopMatrix();
    }



    /**
    *
    * @param gl
    * @param x : coordonnee X du point bas gauche
    * @param y : coordonnee Y du point bas gauche
    * @param z : coordonnee Z du point bas gauche
    * @param largeur : (d�finir coordonnee x du point haut droit)
    * @param hauteur : (d�finir coordonnee y du point haut droit)
	* @param tx : translation selon l'axe x
	* @param ty : translation selon l'axe y
	* @param tz : translation selon l'axe z
	* @param rx : angle de rotation en degre selon l'axe x
	* @param ry : angle de rotation en degre selon l'axe y
	* @param rz : angle de rotation en degre selon l'axe z
    * @param _couleur
    */
	static public void drawRect2D(GL gl, double x, double y, double z,
			double largeur, double hauteur,
	 		double tx, double ty, double tz,
	 		double rx, double ry, double rz, Couleur _couleur)
	{

	    gl.glPushMatrix();

	    gl.glTranslated(x, y, z);


        gl.glPushMatrix();

//        gl.glTranslated(tx,ty,tz);
//        gl.glRotated(rx,1,0,0);
//        gl.glRotated(ry,0,1,0);
//        gl.glRotated(rz,0,0,1);

        setLumiere(gl,false);


        gl.glColor4fv(_couleur.getColor4fv());

		gl.glBegin(GL.GL_QUADS);
		gl.glVertex2d(0, 0);
		gl.glVertex2d(largeur, 0);
		gl.glVertex2d(largeur, hauteur);
		gl.glVertex2d(0, hauteur);
		gl.glEnd();

        setLumiere(gl,true);

        gl.glPopMatrix();

	    gl.glPopMatrix();

	}

//	public void calculNormal(GL gl)
//	{
//		AbstractCamera cameraSpherique = this.getGlScene3D().getCurrentCamera();
//        gl.glNormal3d(Math.signum(cameraSpherique.getEyeX()-cameraSpherique.getLookAtX()),Math.signum(cameraSpherique.getEyeY()-cameraSpherique.getLookAtY()),
//        		Math.signum(cameraSpherique.getEyeZ()-cameraSpherique.getLookAtZ()));
////		System.out.println(Math.signum(GLScene3D.getCamera().getEyeX())+";"+
////				Math.signum(GLScene3D.getCamera().getEyeY())+";"+
////				Math.signum(GLScene3D.getCamera().getEyeZ()));
//	}

    static public void dessinerRepereSimple(GL gl)
    {


        gl.glPushMatrix();

        setLumiere(gl,false);
        /**
         * 1ere version du repere avec trois segments
         */
        gl.glBegin(gl.GL_LINES);


        gl.glColor4fv(Couleur.RED.getColor4fv());
        gl.glVertex3f(0.f, 0.f, 0.f);
        gl.glVertex3f(1f, 0.f, 0.f);

        gl.glColor4fv(Couleur.GREEN.getColor4fv());
        gl.glVertex3f(0.f, 0.f, 0.f);
        gl.glVertex3f(0.f, 1f, 0.f);

        gl.glColor4fv(Couleur.BLUE.getColor4fv());
        gl.glVertex3f(0.f, 0.f, 0.f);
        gl.glVertex3f(0.f, 0.f, 1f);
        gl.glEnd();

        setLumiere(gl,true);
        /**
         * afficher le nom de chaque axe
         */
        drawText2D(gl, new String("X"), 0.98f, 0.f, 0.f, Couleur.GREY);
        drawText2D(gl, new String("Y"), 0.f, 0.98f, 0.f, Couleur.GREY);
        drawText2D(gl, new String("Z"), 0.f, 0.f, 0.98f, Couleur.GREY);
        gl.glPopMatrix();


    }


    public static void dessinerRepereStyle(GL gl)
    {

     final float tailleCylindre = 0.9f;
     final float positionConeCylindre = 0.95f;
     final float longueurAxe = 1f;

     /**
      * axe Z
      */
     gl.glPushMatrix();
     gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.BLUE.getGFloat4Value(), 0);
     glut.glutSolidCylinder(0.01f, tailleCylindre*longueurAxe, 10, 10);
     gl.glPopMatrix();
     /**
      * cone au bout de l'axe Z
      */
     gl.glPushMatrix();
     gl.glTranslatef(0,0,tailleCylindre*positionConeCylindre);
     //gl.glRotatef(-90f,1,0,0);
     gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.BLUE.getGFloat4Value(), 0);
     glut.glutSolidCone(0.04f, longueurAxe-tailleCylindre, 10, 10);
     gl.glPopMatrix();

     /**
      * axe Y
      */
     gl.glPushMatrix();
     gl.glRotated(-90,1,0,0);
     gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.GREEN.getGFloat4Value(), 0);
     glut.glutSolidCylinder(0.01f, tailleCylindre*longueurAxe, 10, 10);
     gl.glPopMatrix();
     /**
      * cone au bout de l'axe Y
      */
     gl.glPushMatrix();
     gl.glTranslatef(0,tailleCylindre*positionConeCylindre,0);
     gl.glRotatef(-90f,1,0,0);
     gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.GREEN.getGFloat4Value(), 0);
     glut.glutSolidCone(0.04f, longueurAxe-tailleCylindre, 10, 10);
     gl.glPopMatrix();

     /**
      * axe X
      */
     gl.glPushMatrix();
     gl.glRotatef(90f,0,1,0);
     gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.RED.getGFloat4Value(), 0);
     glut.glutSolidCylinder(0.01f, tailleCylindre*longueurAxe, 10, 10);
     gl.glPopMatrix();
     /**
      * cone au bout de l'axe X
      */
     gl.glPushMatrix();
     gl.glTranslatef(tailleCylindre*positionConeCylindre,0,0);
     gl.glRotatef(90f,0,1,0);
     gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.RED.getGFloat4Value(), 0);
     glut.glutSolidCone(0.04f, longueurAxe-tailleCylindre, 10, 10);
     gl.glPopMatrix();

     /**
      * afficher centre du repere (objet sphere)
      */
     gl.glPushMatrix();
     gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.GREY.getGFloat4Value(), 0);
     glut.glutSolidSphere(0.03,15,15);
     gl.glPopMatrix();


     /**
      * afficher le nom de chaque axe
      */
     gl.glPushMatrix();
     	drawText2D(gl, new String("X"), 0.98f, 0.f, 0.f, Couleur.GREY);
     	drawText2D(gl, new String("Y"), 0.f, 0.98f, 0.f, Couleur.GREY);
     	drawText2D(gl, new String("Z"), 0.f, 0.f, 0.98f, Couleur.GREY);
     gl.glPopMatrix();

    }

    public static  void initDessinDisplayLists(GL gl)
    {
    	/**
    	 * POUVOIR GERER UNIQUEMENT UN SEUL APPEL PUIS BASTA!!!!
    	 */
        REPERE = gl.glGenLists(1);
        gl.glNewList(REPERE, GL.GL_COMPILE);

            dessinerRepereStyle(gl);
        gl.glEndList();
    }






	/** Dessiner une sphere solide ou "fil de fer"
	 * @param gl
	 * @param x : coordonnee X du centre de la sphere
	 * @param y : coordonnee Y du centre de la sphere
	 * @param z : coordonnee Z du centre de la sphere
	 * @param _rayon : rayon de la sphere
	 * @param _couleur : instance de la classe Couleur
	 * @param nbArcs : nombre d'arcs horizontaux et verticaux
	 * @param solide : solide sinon "fil de fer"
	 */
	static public void drawSphere(GL gl, double x, double y, double z, double _rayon, Couleur _couleur,
			int nbArcs, boolean solide)
	{

        gl.glPushMatrix();



        gl.glTranslated(x,y,z);


        gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, _couleur.getGFloat4Value(), 0);

        if(solide) glut.glutSolidSphere(_rayon,nbArcs,nbArcs);
        else
        	glut.glutWireSphere(_rayon,nbArcs,nbArcs);




        gl.glPopMatrix();


	}



	/** Dessiner une pyramide
	 * ATTENTION: Pour ceux qui veulent un SCENE_PYRAMIDION, il y a une fonction pour cela!!!!!!!)
	 * @param gl
	 * @param x coordonnee X du centre de la pyramide
	 * @param y coordonnee Y du centre de la pyramide
	 * @param z coordonnee Z du centre de la pyramide
	 * @param largeur largeur de la base de la pyramide
	 * @param hauteur hauteur de la base de la pyramide
	 * @param _couleur : instance de la classe Couleur
	 */
	public static void drawPyramid(GL gl, double x, double y, double z,
			double largeur, double hauteur, Couleur _couleur)
	{

		gl.glPushMatrix();
		gl.glTranslated(x, y, z);
        gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_DIFFUSE, _couleur.getGFloat4Value(), 0);
		gl.glBegin(GL.GL_TRIANGLES);

		gl.glNormal3d(0,1,1);
		gl.glVertex3d( 0.0f, hauteur/2, 0.0f);  // Haut du triangle de face
	    gl.glVertex3d(-largeur/2,-hauteur/2, largeur/2);  // Bas gauche du triangle de face
	    gl.glVertex3d( largeur/2,-hauteur/2, largeur/2);  // Bas droit du triangle de face
        gl.glNormal3d(1,1,0);
		gl.glVertex3d( 0.0f, hauteur/2, 0.0f);       // Haut du triangle (Droit)
	    gl.glVertex3d( largeur/2,-hauteur/2, largeur/2);       // Gauche du triangle (Droit)
	    gl.glVertex3d( largeur/2,-hauteur/2,-largeur/2);      // Droite du triangle (Droit)
        gl.glNormal3d(0,1,-1);
	    gl.glVertex3d( 0.0f, hauteur/2, 0.0f);  // Haut du triangle (Arriere)
	    gl.glVertex3d( largeur/2, -hauteur/2, -largeur/2); // Gauche du triangle (Arriere)
	    gl.glVertex3d(-largeur/2,-hauteur/2,-largeur/2); // Droite du triangle (Arriere)
	    gl.glNormal3d(-1,1,0);
	    gl.glVertex3d( 0.0f, hauteur/2, 0.0f);   // Haut du triangle (Gauche)
	    gl.glVertex3d(-largeur/2,-hauteur/2,-largeur/2);   // Gauche du triangle (Gauche)
	    gl.glVertex3d(-largeur/2,-hauteur/2,largeur/2);   // Droite du triangle (Gauche)

	    gl.glEnd();

	    gl.glBegin(GL.GL_QUADS);
	    gl.glNormal3d(0,-1,0);
	    gl.glVertex3d(-largeur/2,-hauteur/2,largeur/2);
	    gl.glVertex3d(largeur/2,-hauteur/2,largeur/2);
	    gl.glVertex3d(largeur/2,-hauteur/2,-largeur/2);
	    gl.glVertex3d(-largeur/2,-hauteur/2,-largeur/2);
	    gl.glEnd();

	    gl.glPopMatrix();

	}

	/**
	 * Dessiner un pyramidion
	 * @param gl
	 * @param x coordonnee X du centre du pyramidion
	 * @param y coordonnee Y du centre du pyramidion
	 * @param z coordonnee Z du centre du pyramidion
	 * @param largeur taille du cote du pyramidion
	 * @param hauteurPyramideHaute : hauteur de la pyramide haute d'un pyramidion
	 * @param hauteurPyramideBasse : hauteur de la pyramide basse d'un pyramidion
	 * @param _couleurPyramidionHaute : instance de la classe Couleur pour la pyramide haute
	 * @param _couleurPyramidionBasse : instance de la classe Couleur pour la pyramide basse
	 * @param _couleurCube : instance de la classe Couleur pour le cube composant du pyramidion
	 */
	static public void drawPyramidion(GL gl, double x, double y, double z, double largeur, double hauteurPyramideHaute,
			double hauteurPyramideBasse, Couleur _couleurPyramidionHaute,
			Couleur _couleurPyramidionBasse, Couleur _couleurCube)
	{

		gl.glPushMatrix();
		gl.glTranslated(x,y,z);
		drawCube(gl, 0,0,0,largeur,_couleurCube);
		gl.glTranslated(0,largeur/2+hauteurPyramideHaute/2,0);
		Dessin.drawPyramid(gl, 0, 0, 0, largeur, hauteurPyramideHaute, _couleurPyramidionHaute);
		gl.glTranslated(0,-largeur-hauteurPyramideHaute/2-hauteurPyramideBasse/2,0);
		gl.glRotated(180, 1,0,0);
		Dessin.drawPyramid(gl, 0, 0, 0, largeur, hauteurPyramideBasse, _couleurPyramidionBasse);
		gl.glPopMatrix();



	}

	/**
	 * @return the glScene3D
	 */
	private GLScene3D getGlScene3D() {
		return glScene3D;
	}

	/**
	 * @param glScene3D the glScene3D to set
	 */
	private void setGlScene3D(GLScene3D glScene3D) {
		this.glScene3D = glScene3D;
	}

	private static void setLumiere(GL gl, boolean value)
	{
		if(value)
				gl.glEnable(GL.GL_LIGHTING);
		else
			gl.glDisable(GL.GL_LIGHTING);


	}

	/**
	 *
	 * @param gl : ressources GL
	 * @param texte : instance de la classe String pour preciser la chaine de caracteres � afficher
	 * @param taille : taille du texte; taille max. = 1; taille min. = 0.01
	 * @param x : coordonnee X de placement du premier caractere de la chaine de caracteres
	 * @param y : coordonnee Y de placement du premier caractere de la chaine de caracteres
	 * @param z : coordonnee Z de placement du premier caractere de la chaine de caracteres
	 * @param tx : translation selon l'axe x
	 * @param ty : translation selon l'axe y
	 * @param tz : translation selon l'axe z
	 * @param rx : angle de rotation en degre selon l'axe x
	 * @param ry : angle de rotation en degre selon l'axe y
	 * @param rz : angle de rotation en degre selon l'axe z
	 * @param couleur : instance de la classe Couleur
	 */
	 static public void drawText3D(GL gl, String txt, double taille, double x, double y, double z,
			 double tx, double ty, double tz,
			 double rx, double ry, double rz, Couleur couleur)
	  {
	    gl.glPushMatrix();



        gl.glTranslated(x, y, z);


        gl.glPushMatrix();

        gl.glTranslated(tx,ty,tz);
        gl.glRotated(rx,1,0,0);
        gl.glRotated(ry,0,1,0);
        gl.glRotated(rz,0,0,1);



        if(taille<=0) taille=0.01;
	    gl.glScaled(taille/100, taille/100, taille/100);


	    float width = glut.glutStrokeLength(GLUT.STROKE_MONO_ROMAN, txt);


        setLumiere(gl,false);

	    for (int i = 0; i < txt.length(); i++) {
	      char ch = txt.charAt(i);

		    gl.glColor4fv(couleur.getColor4fv());
	      glut.glutStrokeCharacter(GLUT.STROKE_MONO_ROMAN, ch);
	    }
        setLumiere(gl,true);


        gl.glPopMatrix();

	    gl.glPopMatrix();
	  }

	 /**
	 *
	 * @param gl : ressources GL
     * @param x : coordonnee X du point bas gauche
     * @param y : coordonnee Y du point bas gauche
     * @param z : coordonnee z du point bas gauche
     * @param largeur : (definir coordonnee x du point haut droit)
     * @param hauteur : (definir coordonnee y du point haut droit)
     * @param profondeur : (definir coordonnee z du point haut droit)
	 * @param tx : translation selon l'axe x
	 * @param ty : translation selon l'axe y
	 * @param tz : translation selon l'axe z
	 * @param rx : angle de rotation en degre selon l'axe x
	 * @param ry : angle de rotation en degre selon l'axe y
	 * @param rz : angle de rotation en degre selon l'axe z
	 * @param couleur : instance de la classe Couleur
	 */
	 static public void drawRect3D(GL gl, double x, double y, double z,
			 double largeur, double hauteur, double profondeur,
			 double tx, double ty, double tz,
			 double rx, double ry, double rz, Couleur couleur)
	  {
	    gl.glPushMatrix();

	    gl.glTranslated(x, y, z);


        gl.glPushMatrix();

        gl.glTranslated(tx,ty,tz);
        gl.glRotated(rx,1,0,0);
        gl.glRotated(ry,0,1,0);
        gl.glRotated(rz,0,0,1);

        //setLumiere(gl,false);


        gl.glColor4fv(couleur.getColor4fv());

    	/* x ,y et z au centre du pave */
        // polygon 0
//        gl.glBegin(GL.GL_POLYGON);
//        	gl.glVertex3d(largeur/2, -hauteur/2, -profondeur/2);
//        	gl.glVertex3d(largeur/2, hauteur/2, -profondeur/2);
//        	gl.glVertex3d(largeur/2, hauteur/2, profondeur/2);
//        	gl.glVertex3d(largeur/2, -hauteur/2, profondeur/2);
//        gl.glEnd();
//
//        // polygon 1
//        gl.glBegin(GL.GL_POLYGON);
//    		gl.glVertex3d(largeur/2, hauteur/2, -profondeur/2);
//	    	gl.glVertex3d(-largeur/2, hauteur/2, -profondeur/2);
//	    	gl.glVertex3d(-largeur/2, hauteur/2, profondeur/2);
//        	gl.glVertex3d(largeur/2, hauteur/2, profondeur/2);
//	    gl.glEnd();
//
//	    // polygon 2
//	    gl.glBegin(GL.GL_POLYGON);
//    		gl.glVertex3d(-largeur/2, hauteur/2, -profondeur/2);
//	    	gl.glVertex3d(-largeur/2, -hauteur/2, -profondeur/2);
//	    	gl.glVertex3d(-largeur/2, -hauteur/2, profondeur/2);
//	    	gl.glVertex3d(-largeur/2, hauteur/2, profondeur/2);
//	    gl.glEnd();
//
//        // polygon 3
//        gl.glBegin(GL.GL_POLYGON);
//    		gl.glVertex3d(-largeur/2, -hauteur/2, -profondeur/2);
//        	gl.glVertex3d(largeur/2, -hauteur/2, -profondeur/2);
//        	gl.glVertex3d(largeur/2, -hauteur/2, profondeur/2);
//	    	gl.glVertex3d(-largeur/2, -hauteur/2, profondeur/2);
//	    gl.glEnd();
//
//        // polygon 4
//        gl.glBegin(GL.GL_POLYGON);
//    		gl.glVertex3d(largeur/2, -hauteur/2, profondeur/2);
//        	gl.glVertex3d(largeur/2, hauteur/2, profondeur/2);
//	    	gl.glVertex3d(-largeur/2, hauteur/2, profondeur/2);
//	    	gl.glVertex3d(-largeur/2, -hauteur/2, profondeur/2);
//	    gl.glEnd();
//
        // polygon 5
        gl.glBegin(GL.GL_POLYGON);
    		gl.glVertex3d(-largeur/2, hauteur/2, -profondeur/2);
        	gl.glVertex3d(largeur/2, hauteur/2, -profondeur/2);
        	gl.glVertex3d(largeur/2, -hauteur/2, -profondeur/2);
    		gl.glVertex3d(-largeur/2, -hauteur/2, -profondeur/2);
    	gl.glEnd();

        //setLumiere(gl,true);

        gl.glPopMatrix();

	    gl.glPopMatrix();
	  }



		static public void drawCircle(GL gl, double x, double y, double z,
				double rayon, Couleur _couleur)
		{

		    gl.glPushMatrix();

		    gl.glTranslated(x, y, z);
		    gl.glRotated(-1, 0,0,90);

	        gl.glPushMatrix();



	        setLumiere(gl,false);

	        gl.glPushMatrix();

	        gl.glColor4fv(Couleur.BLACK.getColor4fv());

	        glut.glutSolidCylinder(rayon+0.005, 0.01, 10,10);

	        gl.glPopMatrix();

	        gl.glPushMatrix();

	        //gl.glTranslated(0,0,0.001);

	        gl.glColor4fv(_couleur.getColor4fv());

	        glut.glutSolidCylinder(rayon, 0.01, 10,10);

	        gl.glPopMatrix();

//	        double k=x;
//	        double h=y;
//	        double r=rayon;
//	        double _x,_y;






//		 gl.glBegin(GL.GL_LINES);
//
//		 for (int i = 0;i < 180;i++)
//		 {
//
//		 _x = r * Math.cos(i) - h;
////		 Then to set up the current y value that we need for our vertex
////		 I am setting it to the radius of the circle, times by the sine of
////		 the current value of i, then I am adding k to translate it
//		 _y = r * Math.sin(i) + k;
////		 Then I am drawing the vertex
//		 gl.glVertex3d(_x + k,_y - h,0);
//
////		 Now for the second part of the line, I am doing the same as above, only
////		 I am moving it 0.1 units so that I am not down to points. This also
////		 Lowers the chance of any holes occuring in the circle
//		 _x = r * Math.cos(i + 0.1) - h;
//		 _y = r * Math.sin(i + 0.1) + k;
////		 Then I am drawing the vertex
//		 gl.glVertex3d(_x + k,_y - h,0);
//		 }
//		 gl.glEnd();

		 setLumiere(gl, true);


		 gl.glPopMatrix();

		 gl.glPopMatrix();

		 }

}




